.TH std::experimental::pmr::resource_adaptor,std::pmr::experimental::resource_adaptor 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::experimental::pmr::resource_adaptor,std::pmr::experimental::resource_adaptor \- std::experimental::pmr::resource_adaptor,std::pmr::experimental::resource_adaptor

.SH Synopsis
   Defined in header <experimental/memory_resource>
   template< class Alloc >

   using resource_adaptor = /*resource-adaptor-imp*/<
                                typename                      (library fundamentals TS)
   std::allocator_traits<Alloc>::

                                template
   rebind_alloc<char>>;
   template< class Alloc >
   class /*resource-adaptor-imp*/ : public memory_resource;   (library fundamentals TS)
   // for exposition only

   The alias template resource_adaptor adapts the allocator type Alloc with a
   memory_resource interface. The allocator is rebound to a char value type before it
   is actually adapted (using the resource-adaptor-imp class template), so that
   adapting specializations of the same allocator template always yields the same type,
   regardless of the value type the allocator template is originally instantiated with.

   resource_adaptor is defined in namespace                       (library fundamentals
   std::experimental::pmr, and the base type memory_resorce in    TS)
   this page is std::experimental::pmr::memory_resource.          (until library
                                                                  fundamentals TS v3)
   resource_adaptor is defined in namespace                       (library fundamentals
   std::pmr::experimental, and the base type memory_resorce in    TS v3)
   this page is std::pmr::memory_resource.

   resource-adaptor-imp is a class template whose members are described below. The name
   resource-adaptor-imp is for exposition purposes only and not normative.

   In addition to meeting the Allocator requirements, Alloc must additionally satisfy
   the following requirements:

     * std::allocator_traits<Alloc>::pointer shall be identical to Alloc::value_type*.
     * std::allocator_traits<Alloc>::const_pointer shall be identical to
       Alloc::value_type const*.
     * std::allocator_traits<Alloc>::void_pointer shall be identical to void*.
     * std::allocator_traits<Alloc>::const_const_pointer shall be identical to void
       const*.

   Member types of resource-adaptor-imp

   Member type    Definition
   allocator_type Alloc

   Member functions of resource-adaptor-imp

resource-adaptor-imp::resource-adaptor-imp

   /*resource-adaptor-imp*/() = default;                          \fB(1)\fP (library
                                                                      fundamentals TS)
   /*resource-adaptor-imp*/(const /*resource-adaptor-imp*/&           (library
   other)                                                         \fB(2)\fP fundamentals TS)
       = default;
   /*resource-adaptor-imp*/(/*resource-adaptor-imp*/&& other)     \fB(3)\fP (library
       = default;                                                     fundamentals TS)
   explicit /*resource-adaptor-imp*/(const Alloc& a2);            \fB(4)\fP (library
                                                                      fundamentals TS)
   explicit /*resource-adaptor-imp*/(Alloc&& a2);                 \fB(5)\fP (library
                                                                      fundamentals TS)

   1) Default constructor. Default constructs the wrapped allocator.
   2) Copy constructor. Copy constructs the wrapped allocator from the allocator
   wrapped by other.
   3) Move constructor. Move constructs the wrapped allocator from the allocator
   wrapped by other.
   4) Initializes the wrapped allocator with a2.
   5) Initializes the wrapped allocator with std::move(a2).

.SH Parameters

   other - another resource-adaptor-imp object to copy or move from
   a2    - another Alloc object to copy or move from

resource-adaptor-imp::get_allocator

   allocator_type get_allocator() const;  (library fundamentals TS)

   Returns a copy of the wrapped allocator.

resource-adaptor-imp::operator=

   /*resource-adaptor-imp*/& operator=(const
   /*resource-adaptor-imp*/& other)                           (library fundamentals TS)
       = default;

   Defaulted copy assignment operator. Copy assigns the wrapped allocator from that of
   other.

resource-adaptor-imp::do_allocate

   protected:
   virtual void* do_allocate(std::size_t bytes, std::size_t   (library fundamentals TS)
   alignment);

   Allocates memory using the allocate member function of the wrapped allocator.

resource-adaptor-imp::do_deallocate

   protected:
   virtual void do_deallocate(void *p, std::size_t bytes,     (library fundamentals TS)
   std::size_t alignment);

   Deallocates the storage pointed to by p using the deallocate member function of the
   wrapped allocator.

   p must have been allocated using the allocate member function of an allocator that
   compares equal to the wrapped allocator, and must not have been subsequently
   deallocated.

resource-adaptor-imp::do_is_equal

   protected:
   virtual bool do_is_equal(const memory_resource& other)     (library fundamentals TS)
   const noexcept;

   Let p be dynamic_cast<const /*resource-adaptor-imp*/*>(&other). If p is a null
   pointer value, returns false. Otherwise, return the result of comparing the
   allocators wrapped by *p and *this using operator==.
